package java_thinking.unit_21._21_13;

import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Desc:   13-7 用读写锁来包装 Map
 *              1 避免了 读-写 写-写 冲突
 *              2 ConcurrentHashMap 的性能已经很好了，只需要一个并发的基于散列的映射就可以使用 ConcurrentHashMap
 *              3 但如果需要对另一种Map实现，如 LinkedHashMap 提供并发性更高的访问，就可以用这种技术
 * @author: cww
 * @DateTime: 2019/6/27 9:41
 */

public class ReadWriteMap<K,V> {
    private final Map<K,V> map;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock r = lock.readLock();
    private final Lock w = lock.writeLock();

    public ReadWriteMap(Map<K,V> map) {
        this.map = map;
    }

    /**
     * 对remove(),putAll(),clear()等方法执行相同操作
     * @param key
     * @param value
     * @return
     */
    public V put(K key, V value) {
        w.lock();
        try {
            return map.put(key,value);
        } finally {
            w.lock();
        }
    }

    /**
     * 对其他制度的 Map 方法执行相同的操作
     * @param key
     * @return
     */
    public V get(Object key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }
}
